Network Analysis¶
Networks are manifested in a variety of fields such as social media, global value chains, disease outbreaks, and internet browsing. Network analysis may allow us to:
- determine important actors/pieces within an organization/system
- identify clusters and analyze interconnectivity within a network
- predict a network's future direction
Political blogs prior to the 2004 US Presidential election 
Graph Network¶
- Nodes: entities of interest
- people, organizations, concepts, database tables/relations
- Edges: relationships between the nodes
- may be directional, may represent different types of links within the same network, and may carry weight
- financial transactions, workplace hierarchy, or shared keys between database tables
Simple network graph + Node and Edge lists 
NetworkX¶
- creating, manipulating, visualizing, and studying the structure, dynamics, and functions of complex networks
- can handle up to 10 million nodes and 100 million edges
Functionalities:¶
- generate random and classic networks
- analyze network structure
- build network models
- design new network algorithms
- draw networks
Note: Primarily for graph analysis (not graph viz)¶
- basic drawing functionalities using Matplotlib
- appropriate for simpler networks or for exploratory data analysis
- for more advanced graph viz, use dedicated fully-featured tools like Graphviz
Installation¶
NetworkX requires Python 3.7 or newer.
To install the latest release of the package, run pip install networkx[default].
To install the package without the dependencies (e.g., numpy, scipy), run pip install networkx.
Alternatively, manual downloads are also possible through Network's GitHub or PyPI repositories.
Simple Plotting¶
Graph creation is fundamentally comprised of 5 steps:
- NetworkX package import:
import networkx as nx - Create the graph object:
g = nx.Graph() - Add nodes*:
g.add_node(node) - Add edges:
g.add_edge(node_1, node_2) - Draw the graph:
nx.draw(g)
Note: Step 3 may be skipped as nodes will automatically be created when edges are created between non-existent nodes.
In [14]:
# Create a networkx graph object
my_graph = nx.Graph()
# Add edges to to the graph object
# Each tuple represents an edge between two nodes
my_graph.add_edges_from([
(1,2),
(1,3),
(3,4),
(1,5),
(3,5),
(4,2),
(2,3),
(3,0)])
# Draw the resulting graph
nx.draw(my_graph, with_labels=True, font_weight='bold')
Importing Network Data from a DataFrame (using from_pandas_edgelist)¶
In [15]:
# create a dataframe
df = pd.DataFrame({'from': ['A', 'B', 'C', 'A'],
'to': ['D', 'A', 'E', 'C']})
# create graph object
G = nx.from_pandas_edgelist(df, 'from', 'to')
# plot the network graph
nx.draw(G, with_labels=False, node_size=500, alpha=1, linewidths=20)
Tweaking node coordinates (using pos) and graph elements (matplotlib integration)¶
In [16]:
# create nodes and edges
G = nx.Graph()
G.add_edge(1, 2)
G.add_edge(1, 3)
G.add_edge(1, 5)
G.add_edge(2, 3)
G.add_edge(3, 4)
G.add_edge(4, 5)
# set positions
pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}
options = {
"font_size": 36,
"node_size": 3000,
"node_color": "white",
"edgecolors": "black",
"linewidths": 5,
"width": 5}
nx.draw_networkx(G, pos, **options)
# Set margins for the axes so that nodes aren't clipped
ax = plt.gca()
ax.margins(0.20)
plt.axis("off")
plt.show()
Directed (i.e., Directional) graph (DiGraph)¶
The source node must be specified before the target node
In [17]:
# create graph object
G = nx.DiGraph([(0, 3), (1, 3), (2, 4), (3, 5), (3, 6), (4, 6), (5, 6)])
# group nodes by column
left_nodes = [0, 1, 2]
middle_nodes = [3, 4]
right_nodes = [5, 6]
# set the position according to column (x-coord)
pos = {n: (0, i) for i, n in enumerate(left_nodes)}
pos.update({n: (1, i + 0.5) for i, n in enumerate(middle_nodes)})
pos.update({n: (2, i + 0.5) for i, n in enumerate(right_nodes)})
nx.draw_networkx(G, pos, **options)
# Set margins for the axes so that nodes aren't clipped
ax = plt.gca()
ax.margins(0.20)
plt.axis("off")
plt.show()
Crude Visualization Exercise¶
Marvel Cinematic Universe Social Network data from Tableau
In [18]:
# import data
msn = pd.read_csv("https://github.com/mkbunyi/Data-Viz-Tutorial-NetworkX/raw/main/marvel_social_network.csv")
msn.head()
Out[18]:
Reformat the data from "long" to "wide" format¶
In [19]:
# reformat to combine linked characters in 1 row
# collapse rows by line ID and combine linked characters in a list per cell
msn_nx = msn.groupby('Line ID').agg(lambda x: x.tolist())
msn_nx = msn_nx[["Character Name","Character ID"]]
# split list and allocate separate columns for the linked characters
msn_nx = pd.concat([msn_nx["Character Name"].apply(pd.Series),
msn_nx["Character ID"].apply(pd.Series)],
axis=1).reset_index()
# add relation type
msn_nx = msn_nx.merge(msn[["Line ID","Relation","Relation Sentiment"]],
on="Line ID", how = "left").drop_duplicates()
# rename columns
msn_nx.columns = ['Line ID', 'Char1_Name', 'Char2_Name', 'Char1_ID', 'Char2_ID', 'Relation', 'Relation Sentiment']
# reset index
msn_nx = msn_nx.reset_index()
# set color according to relation sentiment
msn_nx['color'] = np.where(msn_nx['Relation Sentiment']=="Positive",
"green",
"black")
msn_nx['color'] = np.where(msn_nx['Relation Sentiment']=="Negative",
"red",
msn_nx['color'])
In [11]:
# view reformatted data
msn_nx.head()
Out[11]:
Create graph object¶
In [9]:
# Initialize a graph object
G = nx.from_pandas_edgelist(msn_nx,
'Char1_Name',
'Char2_Name',
edge_attr=["Relation","Relation Sentiment"])
In [10]:
# Generate layout for visualization
pos = nx.kamada_kawai_layout(G)
In [11]:
# Manual position tweaking
pos["Captain America"] += (0, -1)
Tweaking node size¶
We will set node size proportional to the number of links.
In [12]:
# node size is proportional to number of links
links=dict.fromkeys(G.nodes(),0.0)
for (node1,node2,attrib) in G.edges(data=True):
links[node1]+=1
links[node2]+=1
In [15]:
fig, ax = plt.subplots(figsize=(40, 40))
# draw edges
nx.draw_networkx_edges(G, pos, alpha=1, width=5,
edge_color=[msn_nx["color"][i] for i in list(range(len(msn_nx)))])
# draw nodes
nx.draw_networkx_nodes(G, pos,
node_size = [links[i]*500 for i in G],
node_color="blue", alpha=1,
label=[msn_nx["Char1_Name"][i] for i in list(range(len(msn_nx)))])
# draw labels
label_options = {"ec": "black", "fc": "white", "alpha": .9}
nx.draw_networkx_labels(G, pos, font_size=30, bbox=label_options)
# display title
font = {"color": "black", "fontweight": "bold", "fontsize": 40}
ax.set_title("Marvel Social Network", font)
# Resize figure for label readibility
ax.margins(0.1, 0.05)
fig.tight_layout()
plt.axis("off")
plt.show()
Subsetting and NetworkX's graph analysis functions¶
In [18]:
# initialize
top_links = {}
# iterate through nodes to count connections
for char in G.nodes:
top_links[char] = len(G[char])
# convert to dataframe
s = pd.Series(top_links, name='connections')
df = s.to_frame().sort_values('connections', ascending=False)
df
Out[18]:
In [19]:
msn_blackwidow = msn_nx[msn_nx["Char1_Name"]=="Black Widow"].reset_index()
msn_blackwidow.head
Out[19]:
Visualization of Black Widow's network¶
We will use the spring layout, which will put Black Widow in the middle of the graph.
In [20]:
# initialize plot
fig, ax = plt.subplots(figsize=(10, 8))
# Initialize a graph object
G = nx.from_pandas_edgelist(msn_blackwidow,
'Char1_Name',
'Char2_Name',
edge_attr=["Relation","Relation Sentiment"])
# Draw using a spring layout
nx.draw_spring(G,with_labels=True,
edge_color=[msn_blackwidow["color"][i] for i in list(range(len(msn_blackwidow)))],
node_color = "gainsboro",
node_size = 2000,
font_size=11)
# Resize figure for label readibility
fig.tight_layout()
plt.axis("off")
plt.margins(x=0.4)
plt.show()
Other use cases¶
Connected components¶
- Cluster groups according to feature similarities (e.g., same mobile number or address)
- Webs of accounts or channels used by criminal groups
- Transportation clusters
In [21]:
# load in data
cities = pd.read_csv("https://github.com/mkbunyi/Data-Viz-Tutorial-NetworkX/raw/main/distances.csv")
cities.head()
Out[21]:
In [22]:
# create graph object along with nodes and edges
g = nx.Graph()
for edge in range(len(cities)):
g.add_edge(cities["node1"][edge],
cities["node2"][edge],
weight = cities["distance"][edge])
connected_components function to identify distinct sub-groups¶
In [23]:
for i, x in enumerate(nx.connected_components(g)):
print("cc"+str(i)+":",x)
Visualization¶
'spring layout': set k as the optimal distance between nodes. The higher the value for k, the larger the distance between nodes.
In [24]:
# set layout
pos = nx.spring_layout(g, k=5, seed=10)
# plot the network
nx.draw(g,pos,
with_labels = True, #labels nodes
node_color='lightsteelblue',
edge_color='slategrey')
# label edges (distance between cities)
edge_labels = nx.get_edge_attributes(g,'weight')
nx.draw_networkx_edge_labels(g,pos,edge_labels=edge_labels,
font_size=9,rotate=False)
plt.show()
In [25]:
print(nx.shortest_path_length(g, 'Frankfurt','Stuttgart',weight='weight'))
print(nx.shortest_path(g, 'Frankfurt','Stuttgart',weight='weight'))
Pagerank¶
This algorithm measures node importance based on the number and quality of its (incoming and outgoing) links. Its use cases include:
- Ranking of websites, tweets, or Facebook users
- Most influential papers based on citations
- Central actors in organized criminal networks
3. Centrality measures¶
NetworkX covers various centrality measures, such as:
- based on number of links
- crude popularity measure
- Use cases:
- distance from a node to all other nodes
- favor nodes that have the shortest average distance to all other nodes
- Use cases:
- important actors within organizational networks (e.g., terrorist groups)
- spread of infections
- key words/phrases within a document.
- number of times that node is included in the shortest path between two other nodes
- ability to bridge clusters within the network
- Use cases:
